home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / semantic.h < prev    next >
C/C++ Source or Header  |  1999-05-14  |  53KB  |  1,174 lines
  1. // $Id: semantic.h,v 1.10 1999/03/10 19:59:21 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #ifndef semantic_INCLUDED
  11. #define semantic_INCLUDED
  12.  
  13. #include "config.h"
  14. #ifndef __amigaos__
  15. #include <wchar.h>
  16. #endif
  17. #include "ast.h"
  18. #include "diagnose.h"
  19. #include "error.h"
  20. #include "symbol.h"
  21. #include "control.h"
  22. #include "tuple.h"
  23. #include "set.h"
  24.  
  25. class cp_info;
  26. class TypeShadowSymbol;
  27.  
  28. //
  29. //
  30. //
  31. class SymbolTableStack
  32. {
  33. public:
  34.     void Push(SymbolTable *symtab) { table.Next() = symtab; }
  35.     void Pop()                     { if (table.Length() > 0) table.Reset(table.Length() - 1); }
  36.     int Size()                     { return table.Length(); }
  37.     SymbolTable *Top()             { return (SymbolTable *) (table.Length() > 0 ? table[table.Length() - 1] : NULL); }
  38.  
  39.     SymbolTable *operator[](const int i) { return table[i]; } /*  */
  40.  
  41.     //
  42.     // Search for a variable in a stack of symbol tables starting at the current symbol table
  43.     // and ending with the symbol table of the method from which this call originates.
  44.     //
  45.     VariableSymbol *FindVariableSymbol(NameSymbol *name_symbol)
  46.     {
  47.         for (int i = table.Length() - 1; i >= 0; i--)
  48.         {
  49.             VariableSymbol *symbol = table[i] -> FindVariableSymbol(name_symbol);
  50.             if (symbol)
  51.                 return symbol;
  52.         }
  53.         return (VariableSymbol *) NULL;
  54.     }
  55.  
  56.     //
  57.     // Search for a type in a stack of symbol tables starting at the current symbol table
  58.     // and ending with the symbol table of the method from which this call originates.
  59.     //
  60.     TypeSymbol* FindTypeSymbol(NameSymbol *name_symbol)
  61.     {
  62.         for (int i = table.Length() - 1; i >= 0; i--)
  63.         {
  64.             TypeSymbol *symbol = table[i] -> FindTypeSymbol(name_symbol);
  65.             if (symbol)
  66.                 return symbol;
  67.         }
  68.         return (TypeSymbol *) NULL;
  69.     }
  70.  
  71.     //
  72.     // Search for a label in a stack of symbol tables starting at the current symbol table
  73.     // and ending with the symbol table of the method from which this call originates.
  74.     //
  75.     LabelSymbol* FindLabelSymbol(NameSymbol *name_symbol)
  76.     {
  77.         for (int i = table.Length() - 1; i >= 0; i--)
  78.         {
  79.             LabelSymbol *label = table[i] -> FindLabelSymbol(name_symbol);
  80.             if (label)
  81.                 return label;
  82.         }
  83.         return (LabelSymbol *) NULL;
  84.     }
  85.  
  86. private:
  87.     Tuple<SymbolTable *> table;
  88. };
  89.  
  90.  
  91. //
  92. //
  93. //
  94. class ExceptionTableStack
  95. {
  96. public:
  97.     void Push(SymbolSet *set) { table.Next() = set; }
  98.     void       Pop()          { if (table.Length() > 0) table.Reset(table.Length() - 1); }
  99.     int        Size()         { return table.Length(); }
  100.     SymbolSet *Top()          { return (SymbolSet *) (table.Length() > 0 ? table[table.Length() - 1] : NULL); }
  101.  
  102. private:
  103.     Tuple<SymbolSet *> table;
  104. };
  105.  
  106.  
  107. //
  108. //
  109. //
  110. class StatementStack
  111. {
  112. public:
  113.     void Push(Ast *stmt) { info.Next() = stmt; }
  114.     void Pop()           { if (info.Length() > 0) info.Reset(info.Length() - 1); }
  115.     int Size()           { return info.Length(); }
  116.     Ast *Top()           { return (Ast *) (info.Length() > 0 ? info[info.Length() - 1] : NULL); }
  117.  
  118.     Ast *operator[](const int i) { return info[i]; }
  119.  
  120. private:
  121.     Tuple<Ast *> info;
  122. };
  123.  
  124.  
  125. //
  126. //
  127. //
  128. class BlockStack
  129. {
  130. public:
  131.     int max_size;
  132.  
  133.     void Push(AstBlock *block_)
  134.     {
  135.         block.Next() = block_;
  136.         index.Next() = 0;
  137.         if (block.Length() > max_size)
  138.             max_size = block.Length();
  139.     }
  140.  
  141.     void Pop()
  142.     {
  143.         int len = block.Length() - 1;
  144.         if (len >= 0)
  145.         {
  146.             block.Reset(len);
  147.             index.Reset(len);
  148.         }
  149.     }
  150.  
  151.     int Size() { return block.Length(); }
  152.     AstBlock *TopBlock() { return (AstBlock *) (block.Length() > 0 ? block[block.Length() - 1] : NULL); }
  153.  
  154.     AstBlock *operator[](const int i) { return block[i]; }
  155.  
  156.     int &TopMaxEnclosedVariableIndex()
  157.     {
  158.         if (index.Length() <= 0)
  159.             assert(0);
  160.         return index[index.Length() - 1];
  161.     }
  162.  
  163.     BlockStack() : max_size(0) {}
  164.  
  165. private:
  166.     Tuple<AstBlock *> block;
  167.     Tuple<int> index;
  168. };
  169.  
  170.  
  171. //
  172. //
  173. //
  174. class DefiniteFinalAssignmentStack
  175. {
  176. public:
  177.     void Push() { info.Next().Reset(); }
  178.     void Pop()  { if (info.Length() > 0) info.Reset(info.Length() - 1); }
  179.     int Size()  { return info.Length(); }
  180.     Tuple <AstExpression *> &Top()  { if (info.Length() == 0) assert(0); return info[info.Length() - 1]; }
  181.  
  182. private:
  183.     Tuple< Tuple<AstExpression *> > info;
  184. };
  185.  
  186.  
  187. //
  188. //
  189. //
  190. class DefiniteSets
  191. {
  192. public:
  193.     DefiniteSets(int set_size) : break_set(set_size),
  194.                                  continue_set(set_size),
  195.                                  return_set(set_size),
  196.                                  throw_set(set_size)
  197.     {}
  198.  
  199.     BitSet break_set,
  200.            continue_set,
  201.            return_set,
  202.            throw_set;
  203.  
  204.     void UniverseInit()
  205.     {
  206.         break_set.SetUniverse();
  207.         continue_set.SetUniverse();
  208.         return_set.SetUniverse();
  209.         throw_set.SetUniverse();
  210.     }
  211.  
  212.     void EmptyInit()
  213.     {
  214.         break_set.SetEmpty();
  215.         continue_set.SetEmpty();
  216.         return_set.SetEmpty();
  217.         throw_set.SetEmpty();
  218.     }
  219. };
  220.  
  221.  
  222. //
  223. //
  224. //
  225. class DefiniteBlockStack
  226. {
  227. public:
  228.  
  229.     void Push(AstBlock *block_)
  230.     {
  231.         definite_sets[top_index] -> UniverseInit();
  232.         final_sets[top_index] -> EmptyInit();
  233.  
  234.         block[top_index] = block_;
  235.         top_index++;
  236.     }
  237.  
  238.     void Pop()
  239.     {
  240.         if (top_index > 0)
  241.              top_index--;
  242.         else assert(0);
  243.     }
  244.  
  245.     int Size()                 { return top_index; }
  246.     AstBlock *Block(int i)     { return block[i]; }
  247.     AstBlock *TopBlock()       { assert(top_index > 0); return block[top_index - 1]; }
  248.  
  249.     BitSet &BreakSet(int i)    { return definite_sets[i] -> break_set; }
  250.     BitSet &ContinueSet(int i) { return definite_sets[i] -> continue_set; }
  251.     BitSet &ReturnSet(int i)   { return definite_sets[i] -> return_set; }
  252.     BitSet &ThrowSet(int i)    { return definite_sets[i] -> throw_set; }
  253.  
  254.     BitSet &TopBreakSet()      { assert(top_index > 0); return definite_sets[top_index - 1] -> break_set; }
  255.     BitSet &TopContinueSet()   { assert(top_index > 0); return definite_sets[top_index - 1] -> continue_set; }
  256.     BitSet &TopReturnSet()     { assert(top_index > 0); return definite_sets[top_index - 1] -> return_set; }
  257.     BitSet &TopThrowSet()      { assert(top_index > 0); return definite_sets[top_index - 1] -> throw_set; }
  258.  
  259.     BitSet &TopExitSet(BitSet &start_set)
  260.     {
  261. assert(top_index > 0);
  262.         exit_set  = start_set;
  263.         exit_set *= TopBreakSet();
  264.         exit_set *= TopContinueSet();
  265.         exit_set *= TopReturnSet();
  266.         exit_set *= TopThrowSet();
  267.  
  268.         return exit_set;
  269.     }
  270.  
  271.     BitSet &FinalBreakSet(int i)    { return final_sets[i] -> break_set; }
  272.     BitSet &FinalContinueSet(int i) { return final_sets[i] -> continue_set; }
  273.     BitSet &FinalReturnSet(int i)   { return final_sets[i] -> return_set; }
  274.     BitSet &FinalThrowSet(int i)    { return final_sets[i] -> throw_set; }
  275.  
  276.     BitSet &TopFinalBreakSet()      { assert(top_index > 0); return final_sets[top_index - 1] -> break_set; }
  277.     BitSet &TopFinalContinueSet()   { assert(top_index > 0); return final_sets[top_index - 1] -> continue_set; }
  278.     BitSet &TopFinalReturnSet()     { assert(top_index > 0); return final_sets[top_index - 1] -> return_set; }
  279.     BitSet &TopFinalThrowSet()      { assert(top_index > 0); return final_sets[top_index - 1] -> throw_set; }
  280.  
  281.     BitSet &TopFinalExitSet(BitSet &start_set)
  282.     {
  283. assert(top_index > 0);
  284.         exit_set  = start_set;
  285.         exit_set += TopFinalBreakSet();
  286.         exit_set += TopFinalContinueSet();
  287.         exit_set += TopFinalReturnSet();
  288.         exit_set += TopFinalThrowSet();
  289.  
  290.         return exit_set;
  291.     }
  292.  
  293.     DefiniteBlockStack(int stack_size_, int set_size) : stack_size(stack_size_),
  294.